#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>

#define COMMAND_SIZE 1024
#define FORMAT "[%s@%s %s]# "

//下面是shell定义的全局数据

#define MAXARGC 128
char * g_argv[MAXARGC];
int g_argc  = 0;

//环境变量表
#define MAX_ENVS 100
char *g_env[MAX_ENVS];
int g_envs=0;

//last exit code
int lastcode=0;

//3. 别名映射表
std::unordered_map<std::string,std::string> alias_list;

//4. 关于重定向，我们关心的内容
#define NONE_REDIR 0
#define INPUT_REDIR 1
#define OUTPUT_REDIR 2
#define APPEND_REDIR 3

int redir=NONE_REDIR;
std::string filename;


void Cd()
{
	if(cmd=="cd")
	{
		if(g_argc == 1)
		{
			std::string home=GetHome();
			if(home.empty()) return true;
			chdir(home.c_str());
		}
		else
		{
			std::string where=g_argv[1];
			if(where == "-")
			{
				//todo
			}
			else if(where == "~")
			{
				//todo
			}
			else
			{
				chdir(where.c_str());
			}
		}
	}
	return true;
}

char cwd[1024];
char cwdenv[1024];

const char *GetUserName()
{
	const char *name=getenv("USER");
	return name == NULL ? "None":name;
}

//const char *GetHostName()
//{
//	const char *hostname=getenv("HOSTNAME");
//	return hostname == NULL ? "None" : hostname;
//}

const char *GetHostName() {
    static char hostname[256];
    if (gethostname(hostname, sizeof(hostname)) == 0)
        return hostname;
    else
        return "None";
}

const char *GetPwd()
{
	//const char *pwd=getenv("PWD");
	const char *pwd=getcwd(cwd,sizeof(cwd));
	if(pwd != NULL)
	{
		snprintf(cwdenv,sizeof(cwdenv),"PWD=%s",cwd);
		putenv(cwdenv);
	}
	return pwd == NULL ? "None" : pwd;
}

const char *GetHome()
{
	const char *home = getenv("HOME");
	return home==NULL? "": home;
}
//
std::string DirName(const char* pwd)
{
#define SLASH "/"
	std::string dir=pwd;
	if(dir==SLASH) return SLASH;
	auto pos=dir.rfind(SLASH);
	if(pos==std::string::npos) return "BUG?";
	return dir.substr(pos+1);
}

void MakeCommandLine(char cmd_prompt[],int size)
{
	snprintf(cmd_prompt,size,FORMAT,GetUserName(),GetHostName(),DirName(GetPwd()).c_str());
	//snprintf(cmd_prompt,size,FORMAT,GetUserName(),GetHostName(),GetPwd());
}

void PrintCommandPrompt()
{
	char prompt[COMMAND_SIZE];
	MakeCommandLine(prompt,sizeof(prompt));
	printf("%s",prompt);
	fflush(stdout);
}

bool GetCommandLine(char *out,int size)
{
	char *c=fgets(out,sizeof(out),stdin);
	if(c  == NULL) return 1;
	out[strlen(out)-1] = 0;
	if(strlen(out)==0) return false;
	return true;
}

bool CommandParse(char *commandline)
{
#define SEP " "
	g_argc=0;
	g_argv[g_argc++] = strtok(commandline,SEP);
	while((bool)(g_argv[g_argc++] = strtok(nullptr, SEP)));
	g_argc--;
	return g_argc > 0?true:false;
}

void PrintArgv()
{
	for(int i=0;g_argv[i];i++)
	{
		printf("argv[%d]->%s\n",i,g_argv[i]);
	}
	printf("argc: %d\n",g_argc);
}
bool CheckAndBuiltin()
{
	std::string cmd=g_argv[0];
	if(cmd=="cd")
	{
		Cd();
		return true;
	}
	else if(cmd == "echo")
	{
		if(g_argc ==2 )
		{
			// echo "hello world"
			// echo $?
			// echo $PATH
			std::string opt=g_argv[1];
			if(opt == "$?")
			{
				std::cout<<lastcode<<std::endl;
				lastcode=0;
				return true;
			lastcode=0;
			}
			else if(opt[0] == "$")
			{
				std::string env_name=opt.substr(1);
				const char *env_value= getenv(env_name.c_str());
				if(env_name)
					std::cout<<env_name<<std::endl;
			}
			else
			{
				std::cout<<opt<<std::endl;
			}
		}
		else if(cmd == "export")
		{

		}

		return true;
	}

	return false;

}
int Execute()
{
	pid_t id=fork();
	if(id == 0)
	{
		//child
		execvp(g_argv[0],g_argv);
		exit(1);
	}
	int status=0;
	//father
	pid_t rid=waitpid(id,&status,0);
	if(rid > 0)
	{
		lastcode=WEXITSTATUS(status);
	}
	return 0;
}
void InitEnv()
{
	extern char **environ;
	memset(g_nev,0,sizeof(g_env));
	g_envs=0;

	for(int i=0;environ[i];i++)
	{
		g_env[i] = (char*) malloc(strlen(environ[i])+1);
		strcpy(g_env[i],environ[i]);
		g_envs++;
	}
	g_env[g_envs++] = (char*)"HAHA=123456789";
	g_env[g_envs] = NULL;

	for(int i=0;g_env[i];i++)
	{
		putenv(g_env[i]);
	}
}

void TrimSpace(char cmd[],int &end)
{
	while(isspace(cmd[end])) 
	{
		end++;
	}
}
void RedirCheck(char cmd[])
{
	redir = NONE_REDIR;
	filename.clear();
	int start = 0;
	int end = strlen(cmd)-1;

	//"ls -a -l > file.txt"
	while(end > start)
	{
		if(cmd[end] == '<')
		{
			cmd[end++] = 0;
			TrimSpace(cmd,end);
			redir = INPUT_REDIR;
			filename = cmd + end;
			break;
		}
		else if(cmd[end] == '>')
		{
			if(cmd[end -1]== '>')
			{
				//>>
				cmd[end-1] = 0;
				redir=APEND_REDIR;
			}
			else
			{
				//>
				redir = OUTPUT_REDIR;
			}
				cmd[end++]=0;
				TrimSpace(cmd,end);
				filename = cmd+end;
				break;
		}
		else
		{
			end--;
		}
	}
}

int main()
{
	// shell 启动的时候，从系统中获取环境变量
	InitEnv();

	while(true)
	{
		//1. 输出命令行提示符
		PrintCommandPrompt();
		//printf("[%s@%s %s]# ",GetUserName(),GetHostName(),GetPwd());
		//2. 获取用户输入的命令
		char commandline[COMMAND_SIZE];
		if(!GetCommandLine(commandline,sizeof(commandline)))
		{
			continue;
		}
		//3. 重定向分析
		RedirCheck(commandline)
			continue;
		printf("redir: %d,filename: %s\n",redir,filename.c_str());
		//4. 命令行分析 "ls -a -l" -> "ls" "-a" "-l"
		if(CommandParse(commandline))
				continue;
		//PrintArgv();
		//5. 检测并处理內键命令
		CheckAndBuiltin();
			continue;

		//6. 执行命令
		Execute();
	}

	return 0;
}
